package com.etime.shycourse.orde.services.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.etime.shycourse.config.Tools;
import com.etime.shycourse.dto.CurrentUser;
import com.etime.shycourse.orde.dao.BuycarMapper;
import com.etime.shycourse.orde.dao.OrderdetailMapper;
import com.etime.shycourse.orde.dao.OrdersMapper;
import com.etime.shycourse.orde.dto.OrderDetailDto;
import com.etime.shycourse.orde.dto.OrderDetails;
import com.etime.shycourse.orde.dto.groupByStateNumDto;
import com.etime.shycourse.orde.dto.stateNumDto;
import com.etime.shycourse.orde.pojo.Orders;
import com.etime.shycourse.orde.services.interfaces.WxOrdersServices;
import com.etime.shycourse.pojo.SysUser;
import com.etime.shycourse.wx.applets.dao.CourseMapper;
import com.etime.shycourse.wx.applets.pojo.Course;
import com.etime.shycourse.wx.applets.pojo.Orderdetail;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.Date;
import java.util.List;

import static com.etime.shycourse.orde.utils.IdWorker.getIdWorker;

/**
 * @author wb
 * @since 2022-01-10
 */
@Service
public class WxOrdersServiceImpl implements WxOrdersServices {
    @Autowired
    private OrdersMapper mapper;
    @Autowired
    private OrderdetailMapper orderdetailMapper;

    @Autowired
    private CourseMapper courseMapper;
    @Autowired
    private Tools tools;
    @Autowired
    private BuycarMapper buycarMapper;

    /**
     * 统计订单状态的数量
     *
     * @return
     */
    @Override
    public stateNumDto selectStateNumDto() {
        List<groupByStateNumDto> dto = mapper.selectOrdersStateNumDto ();
        if (dto.size () > 0) {
            stateNumDto numDto = new stateNumDto ();
            // 转换 订单-->根据订单状态
            dto.forEach (l -> {
                //1--创建     2--完成	     3--关闭	      4--退款
                if (l.getOrderstate () == 1) {
                    numDto.setCreate (l.getStatenum ());
                }
                if (l.getOrderstate () == 2) {
                    numDto.setFinish (l.getStatenum ());
                }
                if (l.getOrderstate () == 3) {
                    numDto.setClosure (l.getStatenum ());
                }
                if (l.getOrderstate () == 4) {
                    numDto.setRefund (l.getStatenum ());
                }
            });
            return numDto;
        }
        return null;
    }

    /**
     * 插入 订单+订单详情数据
     * (购买课程:下订单需要操作两个数据表：订单表和订单明细表；先保存订单表，然后保存订单明细表；需要有事务管理)*
     * 必须传 orderuserid 其他根据前端需要
     * <p></p>
     * 其他后台的默认设置:
     * 设置订单创建人 ordercreateuserid 登录用户id
     * 设置购买人姓名 当前登录人姓名 orderusertruename
     * 设置订单创建人姓名 ordercreatename 登录用户id
     * 设置订单创建人姓名 ordercreatename 登录用户姓名
     * 设置订单明细表的orderid 为订单orderid
     * <p>
     * 不传值
     * 默认：
     * 订单最后修改时间	orderupdatetime	datetime	当前时间
     * 订单创建时间   ordercreatetime	datetime	当前时间
     * 订单号	orderno	varchar(64)	算法生成 雪花id
     * 订单创建原因	ordercreatereason	varchar(255)	默认：用户下单
     * <p>
     * 微信小程序下单 普通下单
     *
     * @param dto orderDetails
     * @return int 成功 =1 失败=0
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int insertOrderDetails(OrderDetails dto, String token) {
        if (token != null) {
            CurrentUser currentUser = tools.getCurrentUserFromRedis (token);
            // 用户信息不存在
            SysUser user = currentUser.getUser ();
            if (user == null) {
                return 0;
            }
            // 结束
            if (dto != null) {
                int OrderId;
                // 1、订单号	orderno	varchar(64)	算法生成 雪花id
                dto.setOrderno (String.valueOf (getIdWorker ()));
                // 2、设置购买者 orderuserid  登录用户id
                dto.setOrderuserid (user.getUserid ());
                // 3、设置购买人姓名 当前登录人姓名 orderusertruename
                // 微信登录的用户 默认创建的字段是：nickname getNickname
                dto.setOrderusertruename (user.getNickname ());
                // 4、设置订单创建人姓名 ordercreatename 登录用户名  ordercreatename
                dto.setOrdercreatename (user.getNickname ());
                // 5、设置订单创建人id  登录用户id getOrdercreateuserid
                dto.setOrdercreateuserid (user.getUserid ());
                // 创建人姓名 用户名
                dto.setOrdercreatename (user.getNickname ());
                // 6、设置订单创建原因	ordercreatereason	varchar(255)	默认：用户下单
                dto.setOrdercreatereason ("用户下单");
                // 7、设置订单创建时间 ordercreatetime	datetime	当前时间
                dto.setOrdercreatetime (new Date ());
                // 8、设置订单最后修改时间	orderupdatetime	datetime	当前时间
                dto.setOrderupdatetime (new Date ());
                // 9、设置订单 orderstate 默认1-待支付 为了0元购买
                if (dto.getOrderstate () == null) {
                    dto.setOrderstate (1);
                }
                try {
                    // 插入 订单的返回订单 OrderId
                    OrderId = insertOrder (dto);
                    if (OrderId == 0) {
                        throw new Exception ("创建订单失败！");
                    }
                    // 循环添加创建 课程信息
                    dto.getOrderdetailList ().forEach (l -> {
                        // 8、设置订单明细表的orderid 为订单orderid
                        l.setOrderid (OrderId);
                        // 根据课程id 查询出 课程到期时间 coursevaliddays
                        Integer coursevaliddays = selectCourseCoursevaliddays (l.getOdcourseid ());
                        // 设置 订单有效期时间
                        try {
                            l.setOdendtime (addDate (new Date (), coursevaliddays));
                        } catch (Exception e) {
                            System.err.println ("设置订单有效期时间 出错 = " + e);
                            e.printStackTrace ();
                        }
                        //插入 订单的返回订单orderIf 是否成功
                        int orderIf = orderdetailMapper.insert (l);
                        if (orderIf == 0) {
                            try {
                                throw new Exception ("创建订单详情信息失败！");
                            } catch (Exception e) {
                                e.printStackTrace ();
                            }
                        }
                    });
                    return OrderId;
                } catch (Exception e) {
                    e.printStackTrace ();
                    // @Transactional和try catch捕获异常会让注解失效
                    TransactionAspectSupport.currentTransactionStatus ().setRollbackOnly ();
                    return 0;
                }
            }
            return 0;
        }
        return 0;
    }

    // 支招下订单
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int insertSupportOrderDetails(OrderDetails dto, String token) {
        CurrentUser currentUser = tools.getCurrentUserFromRedis (token);
        // 用户信息不存在
        SysUser user = currentUser.getUser ();
        if (user == null) {
            return 0;
        }
        // 您已购买 当课程已经购买了就不创建订单
        // 结束
        if (dto != null) {
            int OrderId;
            // 您已购买 当课程已经购买了就不创建订单
            for (int i = dto.getOrderdetailList ().size () - 1; i >= 0; i--) {
                Integer integer = mapper.countByUserIdCourseLessonId (null, dto.getOrderdetailList ().get (i).getOdlessonid (), user.getUserid ());
                if (integer > 0) {
                    dto.getOrderdetailList ().remove (i);
                }
            }
            // 删除完成 后的数据如果为空了 则不进行创建
            // 删除完成 后的课程详细的 数据如果为空了 则不进行创建
            if (dto.getOrderdetailList ().size () == 0) {
                return 0; // 已经购买完成就不进行购买 返回 -1 已经购买完成就不进行购买 返回 -1
            }
            // 1、订单号	orderno	varchar(64)	算法生成 雪花id
            dto.setOrderno (String.valueOf (getIdWorker ()));
            // 2、设置购买者 orderuserid  登录用户id
            dto.setOrderuserid (user.getUserid ());
            // 3、设置购买人姓名 当前登录人姓名 orderusertruename
            // 微信登录的用户 默认创建的字段是：nickname getNickname
            dto.setOrderusertruename (user.getNickname ());
            // 4、设置订单创建人姓名 ordercreatename 登录用户名  ordercreatename
            // 微信登录的用户 默认创建的字段是：nickname
            dto.setOrdercreatename (user.getNickname ());
            // 5、设置订单创建人id  登录用户id getOrdercreateuserid
            dto.setOrdercreateuserid (user.getUserid ());
            // 6、设置订单创建原因	ordercreatereason	varchar(255)	默认：用户下单
            dto.setOrdercreatereason ("用户下单");
            // 7、设置订单创建时间 ordercreatetime	datetime	当前时间
            dto.setOrdercreatetime (new Date ());
            // 8、设置订单最后修改时间	orderupdatetime	datetime	当前时间
            dto.setOrderupdatetime (new Date ());
            // 9、设置订单 orderstate 默认1-待支付
            dto.setOrderstate (1);
            try {
                // 插入 订单的返回订单 OrderId
                OrderId = insertOrder (dto);
                if (OrderId == 0) {
                    throw new Exception ("创建订单失败！");
                }
                // 循环添加创建 课程信息
                dto.getOrderdetailList ().forEach (l -> {
                    // 8、设置订单明细表的orderid 为订单orderid
                    l.setOrderid (OrderId);
                    // 根据课程id 查询出 课程到期时间 coursevaliddays
                    Integer coursevaliddays = selectCourseCoursevaliddays (l.getOdcourseid ());
                    // 设置 订单有效期时间
                    try {
                        l.setOdendtime (addDate (new Date (), coursevaliddays));
                    } catch (Exception e) {
                        System.err.println ("设置订单有效期时间 出错 = " + e);
                        e.printStackTrace ();
                    }
                    //插入 订单的返回订单orderIf 是否成功
                    int orderIf = orderdetailMapper.insert (l);
                    if (orderIf == 0) {
                        try {
                            throw new Exception ("创建订单详情信息失败！");
                        } catch (Exception e) {
                            e.printStackTrace ();
                        }
                    }
                });
            } catch (Exception e) {
                e.printStackTrace ();
                // @Transactional和try catch捕获异常会让注解失效
                TransactionAspectSupport.currentTransactionStatus ().setRollbackOnly ();
                return 0;
            }
            return OrderId;
        }
        return 0;
    }

    // 在购物车购买 下订单
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int insertOrderDetailsByCar(OrderDetails dto, String token) {
        CurrentUser currentUser = tools.getCurrentUserFromRedis (token);
        // 用户信息不存在
        SysUser user = currentUser.getUser ();
        if (user == null) {
            return 0;
        }
        // 您已购买 当课程已经购买了就不创建订单
        // 结束
        if (dto != null) {
            int OrderId;
            // 1、订单号	orderno	varchar(64)	算法生成 雪花id
            dto.setOrderno (String.valueOf (getIdWorker ()));
            // 2、设置购买者 orderuserid  登录用户id
            dto.setOrderuserid (user.getUserid ());
            // 3、设置购买人姓名 当前登录人姓名 orderusertruename
            dto.setOrderusertruename (user.getNickname ());
            // 4、设置订单创建人姓名 ordercreatename 登录用户名  ordercreatename 微信登录的用户 默认创建的字段是：nickname
            dto.setOrdercreatename (user.getNickname ());
            // 5、设置订单创建人id  登录用户id getOrdercreateuserid
            dto.setOrdercreateuserid (user.getUserid ());
            // 6、设置订单创建原因	ordercreatereason	varchar(255)	默认：用户下单
            dto.setOrdercreatereason ("用户下单");
            // 7、设置订单创建时间 ordercreatetime	datetime	当前时间
            dto.setOrdercreatetime (new Date ());
            // 8、设置订单最后修改时间	orderupdatetime	datetime	当前时间
            dto.setOrderupdatetime (new Date ());
            // 9、设置订单 orderstate 默认1-待支付
            dto.setOrderstate (1);
            if (dto.getOrderdetailList ().size () > 0) {
                try {
                    // 您已购买 当课程已经购买了就不创建订单
                    for (int i = dto.getOrderdetailList ().size () - 1; i >= 0; i--) {
                        // 按照课时购买时
                        if (dto.getOrderdetailList ().get (i).getOdgoodstype () == 4) {
                            Integer integer = mapper.countByUserIdCourseLessonId (null, dto.getOrderdetailList ().get (i).getOdlessonid (), user.getUserid ());
                            if (integer > 0) {
                                // 进行删除购物车操作
                                if (dto.getOrderdetailList ().get (i).getBuycarid () != null) {
                                    // 删除购物车操作
                                    buycarMapper.deleteById (dto.getOrderdetailList ().get (i).getBuycarid ());
                                }
                                // 删除 订单明细
                                dto.getOrderdetailList ().remove (i);
                            }
                        } else if (dto.getOrderdetailList ().get (i).getOdgoodstype () == 1) {
                            // 按照课程购买时
                            Integer integer = mapper.countByUserIdCourseLessonId (dto.getOrderdetailList ().get (i).getOdcourseid (), null, user.getUserid ());
                            if (integer > 0) {
                                if (dto.getOrderdetailList ().get (i).getBuycarid () != null) {
                                    // 进行删除购物车操作
                                    buycarMapper.deleteById (dto.getOrderdetailList ().get (i).getBuycarid ());
                                }
                                // 删除 订单明细
                                dto.getOrderdetailList ().remove (i);
                            }
                        }
                    }
                    // 删除完成 后的课程详细的 数据如果为空了 则不进行创建
                    if (dto.getOrderdetailList ().size () == 0) {
                        return -1;
                        // 已经购买完成就不进行购买 返回 -1 已经购买完成就不进行购买 返回 -1
                    }
                    // 插入 订单的返回订单 OrderId
                    OrderId = insertOrder (dto);
                    if (OrderId == 0) {
                        //throw new Exception ("创建订单失败！");
                        mapper.deleteById (OrderId); //删除创建订单
                        return 0;
                        //不抛出异常 不会删除 手动删除
                    }
                    // 循环添加创建 课程信息
                    dto.getOrderdetailList ().forEach (l -> {
                        // 8、设置订单明细表的orderid 为订单orderid
                        l.setOrderid (OrderId);
                        // 根据课程id 查询出 课程到期时间 coursevaliddays
                        Integer coursevaliddays = selectCourseCoursevaliddays (l.getOdcourseid ());
                        // 设置 订单有效期时间
                        try {
                            l.setOdendtime (addDate (new Date (), coursevaliddays));
                        } catch (Exception e) {
                            System.err.println ("设置订单有效期时间 出错 = " + e);
                            e.printStackTrace ();
                        }
                        //插入 订单的返回订单 orderIf 是否成功
                        int orderIf = orderdetailMapper.insert (l);
                        if (orderIf == 0) {
                            try {
                                throw new Exception ("创建订单详情信息失败！");
                            } catch (Exception e) {
                                e.printStackTrace ();
                            }
                        } else if (l.getBuycarid () != null) {
                            // 购买成功后 删除购物车操作
                            buycarMapper.deleteById (l.getBuycarid ());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace ();
                    // @Transactional和try catch捕获异常会让注解失效
                    TransactionAspectSupport.currentTransactionStatus ().setRollbackOnly ();
                    return 0;
                }
                return OrderId;
            }
            return 0;
        }
        return 0;
    }

    /**
     * 只创建订单 ，没有订单详情 返回订单id
     *
     * @return orderid
     */
    @Override
    public int insertOrder(Orders orders) {
        return mapper.insert (orders) > 0 ? orders.getOrderid () : 0;
    }

    /**
     * 根据订单id 获取订单详情
     * selectOrderDetailsByOrderId
     *
     * @param orderId
     * @return Orders
     */
    @Deprecated
    @Override
    public Orders selectOrderDetailsByOrderId(Integer orderId) {
        return mapper.selectById (orderId);
    }

    @Override
    public Orders selectOrderDetailsByOrderIds(Integer orderId) {
        return mapper.selectOrderDetailsByOrderId (orderId);
    }

    /**
     * * 支招 2022-03-01 10:38:13
     * * 根据订单id 获取订单详情
     */
    @Override
    public Orders selectSupportOrderDetailsByOrderIds(Integer orderId) {
        return mapper.selectOrderDetailsByOrderId (orderId);
    }

    /**
     * 小程序我的订单 我的课程数据接口
     * orderState 待付款，已付款，全部，取消订单，
     * ordercreatetime 按时间降序排列
     *
     * @param token 用户id
     * @return List<Orders>
     */
    @Override
    public List<Orders> selectOrderDetailsByUserId(String token, Integer orderState) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        // 用户
        if (user == null) {
            return null;
        }
        // 用户id
        Integer userId = user.getUser ().getUserid ();
        if (userId == null) {
            return null;
        }
        return mapper.selectOrderDetailsByUserIdOrderState (userId, orderState);
    }

    /**
     * 关闭订单必须要填写关闭订单的原因。如果没有填写，则不能关闭。
     * 关闭订单需要修改orders表的如下字段内容：
     * 前端写入 关闭交易描述	orderclosedesc =输入内容
     * <p>
     * 后台添加 交易关闭时间	orderclosetime	=当前时间
     * 后台添加 关闭交易用户id	ordercloseuserid =登录用户id
     * 后台添加 关闭交易用户姓名orderclosename =登录用户姓名
     * 订单状态 没有传 则后台添加 orderstate = 3
     * <p>
     * upDataOrderById(String token, Orders order)
     *
     * @param order 根据订单id 进行修改
     * @return int
     */
    @Override
    public int upDataOrderById(String token, Orders order) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        // 用户信息
        if (user == null) {
            return 0;
        }
        SysUser sysUser = user.getUser ();
        // 用户信息
        if (sysUser == null) {
            return 0;
        }
        // 1、订单号	orderno	varchar(64)	算法生成 雪花id
        order.setOrderno (String.valueOf (getIdWorker ()));
        // 关闭交易用户id	ordercloseuserid =登录用户id
        order.setOrdercloseuserid (sysUser.getUserid ());
        // 关闭交易用户姓名 orderclosename =登录用户姓名
        order.setOrderclosename (sysUser.getUsertruename ());
        // 交易关闭时间	orderclosetime	=当前时间
        order.setOrderclosetime (new Date ());
        // 订单状态	orderstate = 3
        if (order.getOrderstate () == null) {
            order.setOrderstate (3);
        }
        return mapper.updateById (order);
    }


    /**
     * 2022 - 02 - 10 16:41:37
     * 判断创建订单时 用户是否已经购买其课程(订单为 创建、完成)
     * 存在返回 true
     *
     * @param dto
     * @return boolean
     */
    @Override
    @Deprecated
    public List<Integer> iFBuyCourse(OrderDetailDto dto, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        // 用户信息
        if (user == null) {
            return null;
        }
        SysUser sysUser = user.getUser ();
        // 用户信息
        if (sysUser == null) {
            return null;
        }
        dto.setOrderuserid (sysUser.getUserid ());
        return mapper.iFBuyCourseByOrder (dto);
    }

    /**
     * 在购物车中 下订单前 使用 2022-03-01 12:24:18
     * 根据用户id 判断用户是否有跟本课时
     * 有订单未完成的情况
     *
     * @param List
     * @param token
     * @return Integer  有返回1 没有返回0
     */
    @Override
    public Integer iFBuyCarLesson(List<Orderdetail> List, String token) {
        return null;
    }

    /**
     * 临时后台管理用创建订单
     * 先创建定 返回订单号
     */
    @Override
    public int insetCourseTemporary(OrderDetails orders, SysUser sysUser) {
        // 1、订单号	orderno	varchar(64)	算法生成 雪花id
        orders.setOrderno (String.valueOf (getIdWorker ()));
        // 5、 创建人id  登录用户id 那个用户在操作的传入器id
        orders.setOrdercreateuserid (sysUser.getUserid ());
        // 创建人人姓名 用户名
        orders.setOrdercreatename (sysUser.getUsername ());
        // 购买者id 购买者id orderuserid 为前端传 为那个用户的id
        //订单总结类型orderpricetype 1--现金
        orders.setOrderpricetype (1);
        // 6、设置订单创建原因	ordercreatereason	varchar(255)
        orders.setOrdercreatereason ("后台下单");
        // 7、设置订单创建时间 ordercreatetime	datetime	当前时间
        orders.setOrdercreatetime (new Date ());
        // 修改的时间
        orders.setOrderupdatetime (new Date ());
        // 设置支付时间
        orders.setOrderpaytime (new Date ());
        //
        orders.setOrderpayment ("现金");
        // 9、设置订单 orderstate 默认2-完成
        orders.setOrderstate (2);
        return mapper.insert (orders) > 0 ? orders.getOrderid () : 0;
    }

    /**
     * 临时后台管理用创建订单
     * <p></p>
     * 创建订单明细
     *
     * @param dto
     * @param token
     * @return int
     */
    @Override
    public int insetOrderdetailList(OrderDetails dto, String token) {
        if (token != null) {
            CurrentUser currentUser = tools.getCurrentUserFromRedis (token);
            // 用户信息不存在
            SysUser user = currentUser.getUser ();
            if (user == null) {
                return 0;
            }
            // 结束
            if (dto != null) {
                int OrderId;
                try {
                    // 插入 订单的返回订单 OrderId
                    OrderId = this.insetCourseTemporary (dto, user);
                    if (OrderId == 0) {
                        throw new Exception ("创建订单失败！");
                    }
                    // 循环添加创建 课程信息
                    dto.getOrderdetailList ().forEach (l -> {
                        // 8、设置订单明细表的orderid 为订单orderid
                        l.setOrderid (OrderId);
                        // 设置商品类型 1--课程
                        l.setOdgoodstype (1);
                        // 根据课程id 查询出 课程到期时间 coursevaliddays
                        Integer coursevaliddays = selectCourseCoursevaliddays (l.getOdcourseid ());
                        // 设置 订单有效期时间
                        try {
                            l.setOdendtime (addDate (new Date (), coursevaliddays));
                        } catch (Exception e) {
                            System.err.println ("设置订单有效期时间 出错 = " + e);
                            e.printStackTrace ();
                        }
                        //插入 订单的返回订单 orderIf 是否成功
                        int orderIf = orderdetailMapper.insert (l);
                        if (orderIf == 0) {
                            try {
                                throw new Exception ("创建订单详情信息失败！");
                            } catch (Exception e) {
                                e.printStackTrace ();
                            }
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace ();
                    // @Transactional和try catch捕获异常会让注解失效
                    TransactionAspectSupport.currentTransactionStatus ().setRollbackOnly ();
                    return 0;
                }
                return 1;
            }
        }
        return 0;
    }

    @Override
    public List<Course> searchAllBy(String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        // 用户信息
        if (user == null) {
            return null;
        }
        SysUser sysUser = user.getUser ();
        // 用户信息
        if (sysUser == null) {
            return null;
        }
        return mapper.searchAllBy (sysUser.getUserid ());
    }

    /**
     * 根据id查询订单详情
     *
     * @param orderid 订单id
     * @return
     * @author zw
     */
    @Override
    public Orders selectOrdersById(int orderid) {
        return mapper.selectById (orderid);
    }

    /**
     * 判断永恒有没有
     * 未购买的订单有返回订单id
     * 当用户 有订单存在 状态为1  返回第一个订单id
     * //没有返回0
     *
     * @param token
     * @return int
     */
    @Override
    public int selectByCatOrdersByUserId(String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        // 用户信息
        if (user == null) {
            return 0;
        }
        SysUser sysUser = user.getUser ();
        // 用户信息
        if (sysUser == null) {
            return 0;
        }
        // 当用户 有订单存在 状态为1  返回第一个订单id
        //没有返回0
        List<Orders> ordersList = mapper.selectList (new QueryWrapper<Orders> ().select ("orderid").eq ("orderuserid", sysUser.getUserid ()).eq ("orderstate", 1));
        return ordersList.size () > 0 ? ordersList.get (0).getOrderid () : 0;
    }

    /**
     * 效期增加天数，得到一个新的日期
     *
     * @param date
     * @param day
     * @return Date
     * @throws Exception
     */
    private Date addDate(Date date, long day) throws Exception {
        long time = date.getTime (); // 得到指定日期的毫秒数
        day = day * 24 * 60 * 60 * 1000; // 要加上的天数转换成毫秒数
        time += day; // 相加得到新的毫秒数
        return new Date (time); // 将毫秒数转换成日期
    }

    /**
     * 根据课程id 查询出 课程到期时间 coursevaliddays
     *
     * @param courseId
     * @return Integer
     */

    private Integer selectCourseCoursevaliddays(Integer courseId) {
        Course course = courseMapper.selectOne (new QueryWrapper<Course> ().eq ("courseid", courseId).select ("coursevaliddays"));
        return course.getCoursevaliddays () != null ? course.getCoursevaliddays () : null;
    }

    /**
     * 小程序我的订单 分页
     * orderState 待付款，已付款，全部，取消订单，
     * ordercreatetime 按时间降序排列
     *
     * @param token
     * @return List<Orders>
     */
    @Override
    public Page<Orders> selectOrderDetailsPageByUserId(String token, Integer orderState, Long pagenum, Long pagesize) {
        Page<Orders> page = null;
        if (pagenum != null && pagesize != null) {
            page = new Page<>(pagenum, pagesize);
        } else {
            page = new Page<>();
        }
        CurrentUser user = tools.getCurrentUserFromRedis(token);
        // 用户信息
        if (user == null || user.getUser() == null) {
            return null;
        }
        return mapper.selectOrderDetailsByUserIdOrderStatePage (user.getUser ().getUserid (), orderState, page);
    }
}
